<!DOCTYPE html>
<html lang="en">

<head>
   <meta charset="UTF-8">
   <meta http-equiv="X-UA-Compatible" content="IE=edge">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Document</title>
</head>

<body>
   Object 对象的静态方法22
   1. *Objcect.assign(obj1,obj2,...) 合并对象
   2. *Object.create(XXX[,初始化的对象]) 创建一个对象，原型指向XXX
   Object.create(null) 创建一个没有原型链的空对象
   3.Object.hasOwn(对象，属性)–检查对象中是否含有指定属性
   如果指定的对象具有指定的属性，则 Object.hasOwn() 方法返回 true。
   如果属性被继承或不存在，则该方法返回 false。
   4. Object.fromEntries(arr) 将指定数组（二维数组）转换为对象
   5. Object.getPrototypeOf(XXX) 查找某个对象的原型对象
   6. *Object.setPrototypeOf(obj,原型对象(XXX)) 给obj 修改原型对象(XXX)
   7. Object.getOwnPropertyNames(XXX)方法返回一个数组，
   成员是参数对象本身的所有属性的键名(可枚举)，不包含继承的属性键名
   8. Object.getOwnPropertyDescriptor(obj,prop)
   返回指定对象上一个自有属性对应的属性描述符。（自有属性指的是直接赋予该对象的属性，不需要从原型链上进行查找的属性）.
   如果指定的属性存在于对象上，则返回其属性描述符对象（property descriptor），否则返回 undefined。
   9. Object.getOwnPropertyDescriptors(XXX)
   ES2017 引入了Object.getOwnPropertyDescriptors()方法，
   返回指定对象所有自身属性（非继承属性）的描述对象
   10.Object.getOwnPropertySymbols(XXX)
   返回一个给定对象自身的所有 Symbol 属性的数组
   11.*Object.is(XXX,XXX) 用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致。
   特殊 Object.is(NaN,NaN) true Object.is(+0,-0) false
   12.*Object.keys(XXX)
   ES5 引入了Object.keys方法，返回一个数组，
   成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键名。
   13.*Object.values(XXX)
   Object.values方法返回一个数组，
   成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值。
   14.*Object.entries(XXX)返回一个数组(二维数组)，
   成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值对数组（二维数组）。
   15.*Object.freeze() 冻结一个对象，冻结指的是不能向这个对象添加新的属性，
   不能修改其已有属性的值，不能删除已有属性，以及不能修改该对象已有属性的可枚举性、可配置性、可写性。
   也就是说，这个对象永远是不可变的。该方法返回被冻结的对象。
   不新增，不删除，不修改
   16.*Object.isFrozen(XXX)判断一个对象是否被冻结
   17.*Object.seal(XXX)方法可以让一个对象密封，并返回被密封后的对象。
   密封一个对象会让这个对象变的不能添加新属性，且所有已有属性会变的不可配置。
   属性不可配置的效果就是属性变的不可删除，以及一个数据属性不能被重新定义成为访问器属性，或者反之。
   但属性的值仍然可以修改。
   可修改,不删除,不新增
   18.*Object.isSealed(XXX) 判断一个对象是否被密封（密封，冻结也是true）
   19.*Object.preventExtensions(XXX)对象不能再添加新的属性。 不可扩展
   可修改，删除现有属性，不能添加新属性
   可修改，可删除,不新增
   20.*Object.isExtensible(XXX)判断对象是否是可扩展的，
   Object.preventExtensions，Object.seal 或 Object.freeze 方法
   都可以标记一个对象为不可扩展（non-extensible）---(false)
   21.*Object.defineProperty(obj,prop,descriptor)在一个对象上定义一个新属性，
   或者修改一个对象的现有属性， 并返回这个对象。
   22.*Object.defineProperties(obj,props)直接在一个对象上定义新的属性或修改现有属性，
   并返回该对象。
   https://www.cnblogs.com/zhilu/p/16072774.html
   <script>
      let obj = {
         num: 100
      };
      let obja = { ...obj }//复制一份 obj
      //修改现有属性的时候，成员规则中的 writable,value不可用
      //有了get set 就是实时监控 num的变化
      // get 获取属性的时候触发(obj,newObj)
      // set 修改属性的时候触发(obj,newObj)
      let newObj = Object.defineProperty(obj, "num", {
         get() {//获取值 num的值由get的return决定
            console.log("get");
            //return obj.num;//获取属性的时候触发get,会一直进入死循环
            return obja.num;
         },
         set(val) {//设置值  set可以获取修改的值
            console.log("set");
            if (val === obja.num) { return }
            obja.num = val;
         }
      })

      console.log(newObj);


      // let obj={
      //    num:100
      // };
      // let temp=obj.num;

      // let newObj=Object.defineProperty(obj,"num",{
      //    get(){//获取值 //num的值由get的return决定
      //       console.log("get");
      //       return temp;
      //    },
      //    set(val){//设置值  set可以获取修改的值
      //       console.log("set");
      //       if(val===temp){return}
      //       temp=val;
      //    }
      // })

      // console.log(newObj);


      // let obj={
      //    n:{
      //       m:100
      //    }
      // };
      // let temp=obj.n;

      // //Object.defineProperty不能实现深度监控，可以 循环+递归实现（vue2）
      // //vue3 （Proxy+Reflect）
      // let newObj=Object.defineProperty(obj,"n",{
      //    get(){//获取值 //num的值由get的return决定
      //       console.log("get");
      //       return temp;
      //    },
      //    set(val){//设置值  set可以获取修改的值
      //       console.log("set");
      //       if(val===temp){return}
      //       temp=val;
      //    }
      // })

      // console.log(newObj);



       //let obj={};

       // 1.writable 是否可以修改   false
      //  2.configurable 对否可以删除  false
      //  3.enumerable 是否可枚举   false
      //  4.value 值
      //  let newobj=Object.defineProperty(obj,"name",{
      //     writable:true,
      //     value:"lili"
      //  })

      //  newobj.name="lisa";
      //  console.log(newobj);


      // let resObj=Object.defineProperties(obj,{
      //    name:{
      //      configurable:true,
      //      value:"DayNi"
      //    },
      //    age:{
      //       enumerable:true,//深颜色true  浅颜色false
      //       value:"18"
      //    }
      // })

      // console.log(resObj);






      //  let obj={
      //    name:"lili",
      //    age:18
      //  };

      //  console.dir(Object);

       //Object.seal(obj);
       //Object.freeze(obj);
       //Object.preventExtensions(obj);
    //    obj.num=300;
    //    console.log(Object.isSealed(obj));

       //Object.preventExtensions(obj);//不可扩展
       //Object.freeze(obj);
       //Object.seal(obj);
    //    obj.age=108;
    //    console.log(obj);

      //  console.log(Object.isExtensible(obj)) //false


    //    Object.freeze(obj);
    //    console.log(obj);

    //    console.log(Object.isFrozen(obj))

    //    console.log(Object.keys(obj));
    //    console.log(Object.values(obj));
    //    console.log(Object.entries(obj));

    //    console.log(Object.is(12,"12"));
    //    console.log(12===12);

    //    console.log(Object.is(NaN,NaN));//true
    //    console.log(NaN===NaN);//false

    //    console.log(Object.is(+0,-0));//false
    //    console.log(+0===-0);//true



    //    console.log(Object.hasOwn(obj,"name"));
    //    console.log(Object.hasOwn(obj,"toString"));
    //    console.log(Object.hasOwn(obj,"num"));

       //console.log(Object.getOwnPropertyNames(obj));

    //    console.log(Object.getOwnPropertyDescriptor(obj,"num"));
    //    console.log(Object.getOwnPropertyDescriptors(obj));



        // let arr=[1,2,3];
        // // Object.setPrototypeOf(arr,Date.prototype);
        // // console.log(arr);
        // console.log(Object.getOwnPropertySymbols(Array.prototype));



        // console.log(Object.getPrototypeOf(arr));//Array.prototype

    //    let arrTwo=Object.entries(arr);
    //    console.log(Object.fromEntries(arrTwo));

    //   let obja=Object.create({name:"lili"},{
    //     n:{
    //        writable:true,
    //        configurable:true,
    //        enumerable:true,
    //        value:10
    //     }
    //   });
    //   console.log(obja);

    // let obja=Object.create(null)
    // console.log(obja);


   </script>
</body>

</html>